/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package classi;

import java.io.DataOutputStream;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.RandomAccessFile;

/**
 *
 * @author paolo
 */
public class FileManager {

    RandomAccessFile io;
    FileOutputStream out;
    DataOutputStream outd;
    File f;

    /**
     * Crea una nuova instanza del file, apre la connessione col file specificato nel parametro. N.B. se il file non esiste viene creato.
     * @param pPathFile il path del file con cui si vuole stabilire una connessione.
     */
    public FileManager(String pPathFile) {
        this.f = new File(pPathFile);
        if (!this.f.exists()) {
            try {
                this.f.createNewFile();
            } catch (IOException ex) {
            }
        }
        try {
            this.io = new RandomAccessFile(this.f, "rw");
            this.out = new FileOutputStream(f, true);
            this.outd = new DataOutputStream(this.out);
        } catch (FileNotFoundException e) {
            System.err.println(e);
        }
    }

    /**
     * Scrive sul file con cui si Ã¨ aperta la connessione. N.B. questa funzione sovrascrive il file.
     * @param pStringa la stringa che si vuole scrivere sul file.
     */
    public void scrivi(String pStringa) {
        this.cancella();
        char[] stringa = pStringa.toCharArray();
        for (int i = 0; i < stringa.length; i++) {
            try {
                this.outd.write(stringa[i]);
            } catch (IOException ex) {
            }
        }
    }

    /**
     * Cancella il contenuto del file con cui Ã¨ stata stabita una connessione
     */
    public void cancella() {
        long lunghezza = this.f.length();
        String path = this.f.getPath();
        String dir = "";
        String[] pathname = path.split("/");
        for (int i = 0; i < pathname.length; i++) {
            if (i == pathname.length - 1) {
                path = pathname[i];
            } else {
                dir = dir + pathname[i];
            }
        }
        this.f.delete();
        try {
            this.f.createNewFile();
        } catch (IOException ex) {
        }
        try {
            this.io = new RandomAccessFile(this.f, "r");
            this.out = new FileOutputStream(this.f);
            this.outd = new DataOutputStream(this.out);
        } catch (FileNotFoundException e) {
            System.err.println(e);
        }

    }

    /**
     * Aggiunge una stringa al file con cui si Ã¨ stabilita la connessione.
     * @param pStringa la stringa da aggiungere al file.
     */
    public void aggiungi(String pStringa) {
        char[] str = pStringa.toCharArray();
        for (int i = 0; i < str.length; i++) {
            try {
                this.outd.write(str[i]);
            } catch (IOException e) {
            }
        }
    }

    /**
     * Legge il contenuto del file e lo salva in una stringa.
     * @return Una stringa contenente il contenuto del file con cui si Ã¨ aperta una connessione.
     */
    public String leggi() {
        long lunghezza = this.f.length();
        String retval = "";
        for (int i = 0; i < lunghezza; i++) {
            char c = 0;
            try {
                this.io.seek(i);
            } catch (IOException e) {
            }
            try {
                c = (char) this.io.readByte();
            } catch (IOException ex) {
            }
            retval = retval + c;
        }
        return retval;
    }

    /**
     * Legge il contenuto del file e lo suddivide in parti ad ogni occorrenza di pSeparator trovata.
     * @param pSeparator Una stringa da usare come separatore.
     * @return Un array di stringhe contenente tutte stringhe comprese tra un'occorrenza e l'altra di pSeparator
     */
    public String[] leggi(String pSeparator){
        String str=this.leggi();
        String[] retval=str.split(pSeparator);
        return retval;
    }

    /**
     * Ritorna una specifica stringa tra due occorrenze.
     * Esempio:
     * Questo&Ã¨&un&esempio
     * Con pSeparator & e pId 2 ritornerÃ  la stringa "un"
     * @param pSeparator Una stringa da usare come separatore
     * @param pId L'indice dell'occorrenza.
     * @return Una stringa contenente una determinata stringa tra due occorrenze.
     */
    public String leggi(String pSeparator, int pId){
        String[] str=this.leggi(pSeparator);
        if(pId<str.length){
            return str[pId];
        }
        return "";
    }

    /**
     * Copia il file con cui Ã¨ stata aperta una connessione in un nuovo file;
     *
     * N.B. Se il Path non esiste crea un nuovo file con quel nome.
     * N.B. Il file di origine non viene cancellato.
     * @param pPath Il percorso del file in cui copiare.
     */
    public void copia(String pPath){
        FileManager file= new FileManager(pPath);
        String thisfile=this.leggi();
        file.scrivi(thisfile);
    }
}